// HTML 转义函数（用于代码块）
export const escapeHtml = (text) => {
  const map = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#039;'
  }
  return text.replace(/[&<>"']/g, (m) => map[m])
}

// 格式化消息内容（支持 Markdown）
export const formatMessage = (content) => {
  if (!content) return ''
  
  let formatted = content
  
  // 1. 先处理代码块（避免代码块内的 Markdown 被转换）
  const codeBlocks = []
  formatted = formatted.replace(/```[\s\S]*?```/g, (match) => {
    const id = `__CODE_BLOCK_${codeBlocks.length}__`
    codeBlocks.push(match)
    return id
  })
  
  // 2. 处理引用块（> 开头的行）
  const quoteBlocks = []
  formatted = formatted.replace(/^> (.+)$/gm, (match, content) => {
    const id = `__QUOTE_BLOCK_${quoteBlocks.length}__`
    quoteBlocks.push(content)
    return id
  })
  
  // 3. 处理任务列表（- [ ] 或 - [x]）
  formatted = formatted.replace(/^[-*]\s+\[([ x])\]\s+(.+)$/gm, (match, checked, content) => {
    const isChecked = checked === 'x' || checked === 'X'
    return `<div class="task-item"><input type="checkbox" ${isChecked ? 'checked' : ''} disabled><span class="task-content">${content}</span></div>`
  })
  
  // 4. 处理分隔符 "---"（保持原样，但确保上下有空行间距）
  // 只处理独立行的 ---（至少3个连字符），确保前后有换行
  formatted = formatted.replace(/^[\s]*-{3,}[\s]*$/gm, (match) => {
    // 保持原样，但确保前后有换行（用于段落间距）
    return '\n' + match.trim() + '\n'
  })
  
  // 5. 处理行内代码
  formatted = formatted.replace(/`([^`\n]+)`/g, '<code>$1</code>')
  
  // 6. 处理标题（###, ##, #）- 支持多种格式
  // 支持 ### 标题 和 ###标题（无空格）
  formatted = formatted.replace(/^###\s*(.+)$/gm, '<h3 class="markdown-h3">$1</h3>')
  formatted = formatted.replace(/^##\s*(.+)$/gm, '<h2 class="markdown-h2">$1</h2>')
  formatted = formatted.replace(/^#\s*(.+)$/gm, '<h1 class="markdown-h1">$1</h1>')
  
  // 6.5. 处理中文序号标题（一、二、三、等）- 在有序列表处理之前
  // 匹配中文序号开头的行，如果看起来像标题，则作为标题处理
  // 判断标准：内容较短（<=50字符）且不包含句号，或者下一行是列表项
  const linesForTitle = formatted.split('\n')
  const processedLinesForTitle = []
  for (let i = 0; i < linesForTitle.length; i++) {
    const line = linesForTitle[i]
    const nextLine = i < linesForTitle.length - 1 ? linesForTitle[i + 1] : ''
    const chineseTitleMatch = line.match(/^([一二三四五六七八九十]+[、.])\s*(.+)$/)
    
    if (chineseTitleMatch) {
      const prefix = chineseTitleMatch[1]
      const content = chineseTitleMatch[2].trim()
      // 判断是否为标题：
      // 1. 内容较短（<=50字符）且不包含句号
      // 2. 或者下一行是列表项（以 -、* 或数字开头）
      const isTitle = (content.length <= 50 && !content.includes('。')) ||
                     (nextLine.trim() && (nextLine.trim().startsWith('-') || nextLine.trim().startsWith('*') || nextLine.trim().match(/^\d+[.)]/)))
      
      if (isTitle) {
        processedLinesForTitle.push(`<h2 class="markdown-h2">${prefix} ${content}</h2>`)
      } else {
        processedLinesForTitle.push(line)
      }
    } else {
      processedLinesForTitle.push(line)
    }
  }
  formatted = processedLinesForTitle.join('\n')
  
  // 7. 处理有序列表（1. 2. 3. 或 一、二、三、）
  const lines = formatted.split('\n')
  const processedLines = []
  let inOrderedList = false
  
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i]
    // 跳过任务列表项（已经处理过）
    if (line.includes('task-item')) {
      if (inOrderedList) {
        processedLines.push('</ol>')
        inOrderedList = false
      }
      processedLines.push(line)
      continue
    }
    
    // 匹配数字列表：1. 内容 或 1) 内容
    const orderedMatch = line.match(/^(\d+)[.)]\s*(.+)$/)
    // 匹配中文序号：一、二、三、等（但跳过已经是标题的行）
    const chineseOrderedMatch = !line.includes('markdown-h2') && line.match(/^[一二三四五六七八九十]+[、.]\s*(.+)$/)
    
    if (orderedMatch || chineseOrderedMatch) {
      if (!inOrderedList) {
        processedLines.push('<ol class="markdown-ol">')
        inOrderedList = true
      }
      const content = orderedMatch ? orderedMatch[2] : chineseOrderedMatch[1]
      processedLines.push(`<li class="markdown-li">${content}</li>`)
    } else {
      if (inOrderedList) {
        processedLines.push('</ol>')
        inOrderedList = false
      }
      processedLines.push(line)
    }
  }
  if (inOrderedList) {
    processedLines.push('</ol>')
  }
  formatted = processedLines.join('\n')
  
  // 8. 处理无序列表（- 或 *）- 支持多种格式
  const lines2 = formatted.split('\n')
  const processedLines2 = []
  let inUnorderedList = false
  
  for (let i = 0; i < lines2.length; i++) {
    const line = lines2[i]
    // 跳过任务列表项和引用块占位符
    if (line.includes('task-item') || line.includes('__QUOTE_BLOCK_')) {
      if (inUnorderedList) {
        processedLines2.push('</ul>')
        inUnorderedList = false
      }
      processedLines2.push(line)
      continue
    }
    
    // 匹配 - 内容 或 -内容（有或没有空格，但 - 后面必须有内容）
    // 也匹配 * 内容
    // 排除代码块中的 - 和标题中的 -
    const unorderedMatch = line.match(/^[-*]\s+(.+)$/) || 
                          (line.match(/^[-*](.+)$/) && line.trim().length > 1 && !line.match(/^[-*]{3,}/))
    
    if (unorderedMatch) {
      if (!inUnorderedList) {
        processedLines2.push('<ul class="markdown-ul">')
        inUnorderedList = true
      }
      // 提取列表项内容（去掉 - 或 * 以及可能的空格）
      const content = line.replace(/^[-*]\s*/, '').trim()
      if (content) {
        processedLines2.push(`<li class="markdown-li">${content}</li>`)
      }
    } else {
      if (inUnorderedList) {
        processedLines2.push('</ul>')
        inUnorderedList = false
      }
      processedLines2.push(line)
    }
  }
  if (inUnorderedList) {
    processedLines2.push('</ul>')
  }
  formatted = processedLines2.join('\n')
  
  // 9. 处理表格（在加粗之前，避免表格内容被误处理）
  // 处理表格：找到连续的表格行并转换为HTML表格
  const linesForTable = formatted.split('\n')
  const processedLinesForTable = []
  let inTable = false
  let tableRows = []
  
  for (let i = 0; i < linesForTable.length; i++) {
    const line = linesForTable[i]
    const trimmedLine = line.trim()
    
    // 检查是否是表格行（以 | 开头和结尾，且包含至少一个 |）
    const isTableRow = trimmedLine.startsWith('|') && trimmedLine.endsWith('|') && trimmedLine.split('|').length >= 3
    // 检查是否是分隔行（只包含 |---|---| 这样的格式）
    const isSeparator = /^\|[\s\-:|]+\|\s*$/.test(trimmedLine)
    
    if (isTableRow && !isSeparator) {
      if (!inTable) {
        inTable = true
        tableRows = []
      }
      // 解析表格行
      const cells = trimmedLine.split('|').map(cell => cell.trim()).filter(cell => cell !== '')
      tableRows.push(cells)
    } else if (isSeparator) {
      // 分隔行，跳过
      continue
    } else {
      // 不是表格行，结束当前表格（如果有）
      if (inTable && tableRows.length > 0) {
        // 生成HTML表格（处理单元格中的加粗文本）
        let tableHtml = '<table class="markdown-table">'
        if (tableRows.length > 0) {
          tableHtml += '<thead><tr>'
          tableRows[0].forEach(cell => {
            // 处理单元格中的加粗文本
            let processedCell = cell.replace(/\*\*([^*]+)\*\*/g, '<strong class="markdown-strong">$1</strong>')
            processedCell = processedCell.replace(/__([^_]+)__/g, '<strong class="markdown-strong">$1</strong>')
            tableHtml += `<th>${processedCell}</th>`
          })
          tableHtml += '</tr></thead>'
        }
        if (tableRows.length > 1) {
          tableHtml += '<tbody>'
          for (let j = 1; j < tableRows.length; j++) {
            tableHtml += '<tr>'
            tableRows[j].forEach(cell => {
              // 处理单元格中的加粗文本
              let processedCell = cell.replace(/\*\*([^*]+)\*\*/g, '<strong class="markdown-strong">$1</strong>')
              processedCell = processedCell.replace(/__([^_]+)__/g, '<strong class="markdown-strong">$1</strong>')
              tableHtml += `<td>${processedCell}</td>`
            })
            tableHtml += '</tr>'
          }
          tableHtml += '</tbody>'
        }
        tableHtml += '</table>'
        processedLinesForTable.push(tableHtml)
        tableRows = []
        inTable = false
      }
      processedLinesForTable.push(line)
    }
  }
  
  // 处理最后一个表格（如果文本以表格结尾）
  if (inTable && tableRows.length > 0) {
    let tableHtml = '<table class="markdown-table">'
    if (tableRows.length > 0) {
      tableHtml += '<thead><tr>'
      tableRows[0].forEach(cell => {
        // 处理单元格中的加粗文本
        let processedCell = cell.replace(/\*\*([^*]+)\*\*/g, '<strong class="markdown-strong">$1</strong>')
        processedCell = processedCell.replace(/__([^_]+)__/g, '<strong class="markdown-strong">$1</strong>')
        tableHtml += `<th>${processedCell}</th>`
      })
      tableHtml += '</tr></thead>'
    }
    if (tableRows.length > 1) {
      tableHtml += '<tbody>'
      for (let j = 1; j < tableRows.length; j++) {
        tableHtml += '<tr>'
        tableRows[j].forEach(cell => {
          // 处理单元格中的加粗文本
          let processedCell = cell.replace(/\*\*([^*]+)\*\*/g, '<strong class="markdown-strong">$1</strong>')
          processedCell = processedCell.replace(/__([^_]+)__/g, '<strong class="markdown-strong">$1</strong>')
          tableHtml += `<td>${processedCell}</td>`
        })
        tableHtml += '</tr>'
      }
      tableHtml += '</tbody>'
    }
    tableHtml += '</table>'
    processedLinesForTable.push(tableHtml)
  }
  
  formatted = processedLinesForTable.join('\n')
  
  // 10. 处理加粗 **文本** 或 __文本__（在段落处理之前）
  formatted = formatted.replace(/\*\*([^*]+)\*\*/g, '<strong class="markdown-strong">$1</strong>')
  formatted = formatted.replace(/__([^_]+)__/g, '<strong class="markdown-strong">$1</strong>')
  
  // 11. 处理斜体 *文本* 或 _文本_（不在加粗内，且不在列表项中）
  formatted = formatted.replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, '<em class="markdown-em">$1</em>')
  formatted = formatted.replace(/(?<!_)_([^_\n]+)_(?!_)/g, '<em class="markdown-em">$1</em>')
  
  // 12. 处理删除线 ~~文本~~
  formatted = formatted.replace(/~~([^~]+)~~/g, '<del class="markdown-del">$1</del>')
  
  // 13. 处理链接 [文本](url)
  formatted = formatted.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer" class="markdown-link">$1</a>')
  
  // 14. 处理换行和段落
  // 先将多个连续换行转换为段落分隔
  formatted = formatted.replace(/\n{3,}/g, '\n\n')
  
  // 按段落分割（双换行作为段落分隔）
  const paragraphs = formatted.split(/\n\n+/)
  const processedParagraphs = []
  
  for (const para of paragraphs) {
    const trimmed = para.trim()
    if (!trimmed) continue
    
    // 如果段落是块级元素（标题、列表、水平线、代码块、任务项、表格），直接添加
    if (trimmed.match(/^<(h[1-6]|ul|ol|hr|pre|li|div|table)/) || trimmed.match(/^<\/(h[1-6]|ul|ol|pre|li|div|table)>/)) {
      processedParagraphs.push(trimmed)
      continue
    }
    
    // 如果段落是 "---" 分隔符，作为独立段落处理（保持原样，会有上下间距）
    if (/^-{3,}\s*$/.test(trimmed)) {
      processedParagraphs.push(`<p class="markdown-p markdown-separator">${trimmed}</p>`)
      continue
    }
    
    // 如果包含代码块占位符，需要特殊处理
    if (trimmed.includes('__CODE_BLOCK_')) {
      // 如果整个段落就是代码块占位符，直接添加
      if (/^__CODE_BLOCK_\d+__\s*$/.test(trimmed)) {
        processedParagraphs.push(trimmed)
        continue
      }
      // 如果段落包含代码块占位符和其他内容，需要分割处理
      const parts = trimmed.split(/(__CODE_BLOCK_\d+__)/)
      for (const part of parts) {
        if (part.match(/^__CODE_BLOCK_\d+__$/)) {
          processedParagraphs.push(part)
        } else if (part.trim()) {
          const processed = part.replace(/\n/g, '<br>')
          processedParagraphs.push(`<p class="markdown-p">${processed}</p>`)
        }
      }
      continue
    }
    
    // 如果段落包含 <hr>，分割处理
    if (trimmed.includes('<hr>')) {
      const parts = trimmed.split(/<hr>/)
      for (let i = 0; i < parts.length; i++) {
        if (parts[i].trim()) {
          // 将单换行转换为 <br>
          const processed = parts[i].replace(/\n/g, (match, offset, string) => {
            const before = string.substring(Math.max(0, offset - 30), offset)
            const after = string.substring(offset + 1, Math.min(string.length, offset + 31))
            if (before.match(/<\/[ou]l>|<\/h[1-6]>|^<[ou]l>|<h[1-6]>/)) {
              return ''
            }
            if (after.match(/^<[ou]l>|^<h[1-6]>/)) {
              return ''
            }
            return '<br>'
          })
          processedParagraphs.push(`<p class="markdown-p">${processed}</p>`)
        }
        if (i < parts.length - 1) {
          processedParagraphs.push('<hr>')
        }
      }
      continue
    }
    
    // 普通段落，将单换行转换为 <br>
    const processed = trimmed.replace(/\n/g, (match, offset, string) => {
      const before = string.substring(Math.max(0, offset - 30), offset)
      const after = string.substring(offset + 1, Math.min(string.length, offset + 31))
      if (before.match(/<\/[ou]l>|<\/h[1-6]>|^<[ou]l>|<h[1-6]>/)) {
        return ''
      }
      if (after.match(/^<[ou]l>|^<h[1-6]>/)) {
        return ''
      }
      return '<br>'
    })
    processedParagraphs.push(`<p class="markdown-p">${processed}</p>`)
  }
  
  formatted = processedParagraphs.join('')
  
  // 清理多余的 <p> 标签嵌套
  formatted = formatted.replace(/<p[^>]*>\s*<p[^>]*>/g, '<p class="markdown-p">')
  formatted = formatted.replace(/<\/p>\s*<\/p>/g, '</p>')
  
  // 14. 恢复引用块（在代码块恢复之前，避免代码块被重复处理）
  quoteBlocks.forEach((quote, index) => {
    const id = `__QUOTE_BLOCK_${index}__`
    // 简单处理引用内容（不递归，避免无限循环）
    let processedQuote = quote
    // 只处理基本的格式
    processedQuote = processedQuote.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
    processedQuote = processedQuote.replace(/\*([^*\n]+)\*/g, '<em>$1</em>')
    processedQuote = processedQuote.replace(/`([^`\n]+)`/g, '<code>$1</code>')
    formatted = formatted.replace(id, `<blockquote class="markdown-blockquote">${processedQuote}</blockquote>`)
  })
  
  // 15. 恢复代码块（带样式和复制功能）
  codeBlocks.forEach((block, index) => {
    const id = `__CODE_BLOCK_${index}__`
    const match = block.match(/```(\w+)?\n?([\s\S]*?)```/)
    if (match) {
      const lang = match[1] || 'text'
      const code = match[2].trim()
      const codeId = `code-${Date.now()}-${index}`
      // 使用 data 属性存储代码，通过事件委托处理复制
      const encodedCode = encodeURIComponent(code)
      formatted = formatted.replace(id, `
        <div class="code-block-wrapper">
          <div class="code-block-header">
            <span class="code-lang">${lang}</span>
            <button class="code-copy-btn" data-code="${encodedCode}" data-copy-id="${codeId}">
              复制
            </button>
          </div>
          <pre class="code-block"><code class="language-${lang}" id="${codeId}">${escapeHtml(code)}</code></pre>
        </div>
      `)
    } else {
      const code = block.replace(/```/g, '').trim()
      const codeId = `code-${Date.now()}-${index}`
      const encodedCode = encodeURIComponent(code)
      formatted = formatted.replace(id, `
        <div class="code-block-wrapper">
          <div class="code-block-header">
            <span class="code-lang">text</span>
            <button class="code-copy-btn" data-code="${encodedCode}" data-copy-id="${codeId}">
              复制
            </button>
          </div>
          <pre class="code-block"><code id="${codeId}">${escapeHtml(code)}</code></pre>
        </div>
      `)
    }
  })
  
  return formatted
}

